import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

//OR59 字符串中找出连续最长的数字串
//注意使用isDight当前字母是否是数字
//isLetter当前字母是否是字母
//都是返回boolean
class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String s = reader.readLine();

        int start = 0;
        int end = 0;
        int len = 0;
        int max = 0;

        // 遍历字符串，找到最长数字子串
        for (int i = 0; i < s.length(); i++) {
            if (Character.isDigit(s.charAt(i))) {
                len++;  // 如果是数字，增加当前数字串的长度
            } else {
                // 遇到非数字字符时，检查当前数字串是否更长
                if (len > max) {
                    start = i - len;  // 记录最长数字串的起始位置
                    end = i - 1;      // 记录最长数字串的结束位置
                    max = len;        // 更新最大长度
                }
                len = 0;  // 重置数字串的长度
            }

            // 如果到达字符串末尾，检查是否需要更新
            if (i == s.length() - 1 && len > max) {
                start = i - len + 1;
                end = i;
            }
        }

        // 输出最长数字串
        if (max > 0) {
            System.out.print(s.substring(start, end + 1));
        } else {
            System.out.print("");  // 如果没有数字串，输出空字符串
        }
    }
}



//NC109 岛屿数量
public class Solution {
    // 定义四个方向的变化，分别是右、下、左、上
    int[] dx = {1, 0, -1, 0};
    int[] dy = {0, 1, 0, -1};

    public int solve(char[][] grid) {
        int ans = 0;
        int n = grid.length;
        int m = grid[0].length;

        // 遍历网格
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果是岛屿部分
                if (grid[i][j] == '1') {
                    dfs(grid, i, j, n, m);
                    ans++; // 每次调用 DFS 说明找到了一个岛屿
                }
            }
        }
        return ans;
    }

    // 深度优先搜索，用来将与当前岛屿相连的部分标记为已访问
    public void dfs(char[][] grid, int x, int y, int n, int m) {
        // 检查边界条件
        if (x < 0 || y < 0 || x >= n || y >= m || grid[x][y] == '0') {
            return;
        }

        // 标记当前格子为已访问
        grid[x][y] = '0';

        // 遍历四个方向
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            dfs(grid, nx, ny, n, m); // 递归搜索
        }
    }
}




//拼三角
class Main1 {
    public static void main(String args[]) {
        // 创建扫描器用于接收输入
        Scanner s = new Scanner(System.in);

        // 读取测试用例的数量
        int t = s.nextInt();

        // 处理每个测试用例
        for (int i = 0; i < t; i++) {
            // 读取6根火柴的长度
            int[] arr = new int[6];
            for (int j = 0; j < 6; j++) {
                arr[j] = s.nextInt();
            }

            // 排序火柴的长度，便于后续判断
            Arrays.sort(arr);

            // 每次处理新的测试用例时重新初始化 vis 和 path
            // vis 用于记录火柴是否被选中
            // path 用于存放当前选中的3根火柴长度
            boolean[] vis = new boolean[6];
            ArrayList<Integer> path = new ArrayList<>();

            // 调用深度优先搜索（DFS）检查是否可以选出两组有效的三角形
            if (dfs(arr, 0, 0, vis, path)) {
                System.out.println("Yes");  // 如果可以选出两组三角形，输出 Yes
            } else {
                System.out.println("No");   // 否则输出 No
            }
        }

        // 关闭扫描器
        s.close();
    }

    public static boolean dfs(int[] arr, int index, int count, boolean[] vis, ArrayList<Integer> path) {
        // 当我们选了3根火柴，检查是否可以组成一个有效的三角形
        if (count == 3) {
            // 两根最小边之和大于最大边（判断第一个三角形）
            long twoMinSide = path.get(0) + path.get(1);

            // 创建第二组火柴，用于检查第二个三角形
            ArrayList<Integer> second = new ArrayList<>();
            for (int i = 0; i < 6; i++) {
                // 添加没有被选择的火柴到 second 中
                if (!vis[i]) {
                    second.add(arr[i]);
                }
            }

            // 对第二组火柴排序，便于后续检查是否可以组成三角形
            int a = second.get(0), b = second.get(1), c = second.get(2);

            // 判断两个三角形的条件：
            // 1. 第一个三角形满足两边和大于第三边
            // 2. 第二个三角形也满足两边和大于第三边
            return twoMinSide > path.get(2) && (a + b > c);
        }

        // 遍历剩余的火柴，尝试选取3根
        for (int i = index; i < 6; i++) {
            // 如果当前火柴未被选中
            if (!vis[i]) {
                // 标记该火柴为已选中
                vis[i] = true;
                // 把选中的火柴长度加入到 path 中
                path.add(arr[i]);

                // 递归地选取下一个火柴
                if (dfs(arr, i + 1, count + 1, vis, path)) return true;

                // 回溯：取消选中当前火柴，尝试选其他火柴
                vis[i] = false;
                path.remove(path.size() - 1);
            }
        }

        // 如果没有找到符合条件的组合，返回 false
        return false;
    }
}


//拼三角(方法二)
 class Main2
{
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        int[] arr = new int[6];

        while(t-- != 0)
        {
            for(int i = 0; i < 6; i++) arr[i] = in.nextInt();
            Arrays.sort(arr);

            if(arr[0] + arr[1] > arr[2] && arr[3] + arr[4] > arr[5] ||
                    arr[0] + arr[2] > arr[3] && arr[1] + arr[4] > arr[5] ||
                    arr[0] + arr[3] > arr[4] && arr[1] + arr[2] > arr[5] ||
                    arr[0] + arr[4] > arr[5] && arr[1] + arr[2] > arr[3])
            {
                System.out.println("Yes");
            }
            else
            {
                System.out.println("No");
            }
        }
    }
}

